home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Turnbull China Bikeride
/
Turnbull China Bikeride - Disc 2.iso
/
BARNET
/
COMPILER
/
SATHER
/
!Sather
/
Library
/
Containrs
/
sa
/
a_list
< prev
next >
Wrap
Text File
|
1996-04-09
|
5KB
|
181 lines
---------------------------> Sather 1.1 source file <--------------------------
-- a_list.sa: Array based list
-- Author: Benedict A. Gomes <gomes@samosa.ICSI.Berkeley.EDU>
-- Copyright (C) 1995, International Computer Science Institute
-- $Id: a_list.sa,v 1.6 1996/04/09 10:04:31 borisv Exp $
--
-- COPYRIGHT NOTICE: This code is provided WITHOUT ANY WARRANTY
-- and is subject to the terms of the SATHER LIBRARY GENERAL PUBLIC
-- LICENSE contained in the file: Sather/Doc/License of the
-- Sather distribution. The license is also available from ICSI,
-- 1947 Center St., Suite 600, Berkeley CA 94704, USA.
-------------------------------------------------------------------
class LIST{ETP} < $LIST{ETP} is
include A_LIST{ETP};
end;
-------------------------------------------------------------------
class A_LIST{ETP} < $LIST{ETP} is
-- A safe wrapper for FLIST{ETP}
private attr arr: FLIST{ETP};
-- ------ Initialization/Duplication ------
create: SAME is
res ::= new;
res.arr := #FLIST{ETP}(5);
return res;
end;
create_sized(n: INT): SAME post result.size = n is
-- Create a list with "n" empty locations
if n = 0 then return #SAME;
else
res ::= new;
res.arr := FLIST{ETP}::create_empty_sized(n);
return res;
end;
end;
create_from(a: ARRAY{ETP}): SAME is
-- Create an array which contains the elements of "a"
return create(a)
end;
create(a: $ELT{ETP}): SAME is
-- Convert "a" into a list
res: SAME := #;
loop res.append(a.elt!) end;
return res;
end;
resize(n: INT) pre ~void(self) is
-- Allocate a new array and copy whatever will fit of the
-- old portion. Changes the actual size
resarr::=FLIST{ETP}::create_empty_sized(n);
i ::= 0; loop until!(i = n); resarr[i] := elt!; i := i + 1; end;
arr := resarr;
end;
copy:SAME is
-- A copy of self.
res: SAME := create_sized(size);
loop i ::= size.times!;
res[i] := [i];
end;
return res;
end;
copy_from(src:$ELT{ETP}) is
-- Copy as many elements from `src' to self as will fit.
loop set!(src.elt!) end;
end;
-- ------ Insertion/Removal ---------------
remove_index(i: INT) is arr.delete_ordered(i) end;
insert_after(l:INT,v:ETP) pre ~void(self) is
-- Insert v at location i, pushing elements upward
arr := arr.insert_after(l,v);
end;
insert_before(l: INT, v: ETP) pre ~void(self) is
arr := arr.insert_before(l,v);
end;
insert_all_after(l: INT, e: $CONTAINER{ETP}) pre ~void(self) is
arr := arr.insert_all_after(l,e);
end;
insert_all_before(l: INT, e: $CONTAINER{ETP}) pre ~void(self) is
arr := arr.insert_all_before(l,e);
end;
append(a:ETP) is
-- Append element "a", even if a is void
arr := arr.push(a);
end;
append_all(a:$CONTAINER{ETP}) is
-- Append a into self
if void(a) then return
else loop arr := arr.push(a.elt!); end; end;
end;
clear pre ~void(self) is
-- Set each array element to void. Set size to zero
arr.clear
end;
-- ------ Access/Measurement --------------
aget(i: INT): ETP pre has_ind(i) is return arr[i] end;
aset(i: INT,v: ETP) pre has_ind(i) is arr[i] := v end;
size: INT is return arr.size end;
-- ------ Queries/Comparison --------------
has(e: ETP): BOOL is return arr.has(e) end;
-- True if array contains "e"
has_ind(i: INT): BOOL is return ~void(self) and 0<=i and i < size end;
has_range(beg,num: INT): BOOL is
if ~void(self) then
return 0<=beg and beg<size and num>= 0 and beg+num<=size;
else return false end;
end;
equals(a: $RO_ARR{ETP}):BOOL is return arr.equals(a) end;
-- ------ Cursor --------------------------
ind!:INT is
-- Yield the indices of self in order. Self may be void.
i::=0; sz::=size; loop until!(i>=sz); yield i; i := i+1; end;
end;
elt!: ETP is
-- Yield each element of self in order. Self may be void.
if ~void(self) then
sz: INT := size; i::=0;
loop until!(i = sz); yield arr[i]; i := i + 1; end;
end
end;
set!(val:ETP) is
-- Set successive elements of self to the values of `val'.
sz: INT := size; i::=0;
loop until!(i = sz); arr[i] := val; yield; i := i + 1; end;
end;
-- ------ Conversion ----------------------
str: STR is
-- Prints out a string version of the array of the components
-- that are under $STR, and their associated indices
res ::= #FSTR("{");
i:INT :=0; asz ::= size; loop until!(i>=asz);
e ::= [i];
res := res+",".separate!(elt_str(e,i));
i := i + 1;
end;
res := res +"}";
return(res.str);
end;
private elt_str(e: ETP,i: INT): STR is
typecase e
when $STR then return e.str else return "Unprintable:"+i end;
end;
-- subarr(beg,num:INT): LIST{ETP}
-- -- A new array with `num' entries copied from self
-- -- starting at `beg'. Self may not be void.
-- pre ~void(self) and beg.is_bet(0,size-1) and num.is_bet(0,size-beg)
-- is
-- r::=create(num);
-- r.copy_from(beg,num,self);
-- return r
-- end;
end;
--=============================================================================